package com.ms.common.utils;

import cn.hutool.core.util.NumberUtil;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public class NumberUtils extends NumberUtil {

    /**
     * 如果number为空，将number转换为0，否则原数字返回
     *
     * @param number 原数值
     * @return 整型数字，0或原数字
     */
    public static Integer null2Zero(Integer number){
        return number == null ? 0 : number;
    }

    /**
     * 如果number为空，将number转换为0，否则原数字返回
     *
     * @param number 原数值
     * @return 整型数字，0或原数字
     */
    public static Double null2Zero(Double number){
        return number == null ? 0 : number;
    }

    /**
     * 如果是空值，返回默认数据；如果有值直接返回
     * @param number
     * @param defaultNumber
     * @return
     */
    public static double null2Default(Double number, double defaultNumber) {
        return number == null ? defaultNumber : number;
    }

    /**
     * 如果number为空，将number转换为0L，否则原数字返回
     *
     * @param number  原数值
     * @return 长整型数字，0L或原数字
     */
    public static Long null2Zero(Long number){
        return number == null ? 0L : number;
    }

    /**
     * 根据shopId字符串计算机构下面分店数量
     *
     * @param shopIds 分店id 格式：,1,2,3,4,5,6,
     * @return 分店个数
     */
    public static Integer instShopNum(String shopIds) {
        if (StringUtils.isEmpty(shopIds)) {
            return 0;
        }
        String[] strings = shopIds.split(",");
        return (strings.length - 1);
    }

    /**
     * 判断一个Integer类型是不是自然数，不为null并且大于零的为自然数。
     *
     * @param it 数字
     * @return 是不是自然数
     */
    public static boolean isNatural(Integer it) {
        return it != null && it > 0;
    }

    /**
     * 判断一个Integer类型是不是不是自然数，不为null并且大于零的为自然数。
     *
     * @param it 数字
     * @return 是不是不是自然数
     */
    public static boolean isNotNatural(Integer it) {
        return it == null || it <= 0;
    }


    /**
     * 把字符串转换成list
     *
     * @param strings 格式: ,1,2,3,4,5,6,
     * @return list
     */
    public static List<String> transitionList(String strings) {
        String[] split = strings.substring(1).split(",");
        return Arrays.asList(split);
    }

    public static List<Integer> transitionListInt(String strings) {
        List<Integer> intList = new ArrayList<>();
        if (StringUtils.isEmpty(strings)) {
            return intList;
        }

        String[] split = strings.substring(1, strings.length() - 1).split(",");
        for (String it : split) {
            intList.add(Integer.valueOf(it));
        }

        return intList;
    }

    /**
     * 数字样式的字符串转化为数字
     *
     * @param num 可转化的字符串 "123"/""
     * @return 数字 123/0
     */
    public static int parseInt(String num) {
        if (StringUtils.isNotEmpty(num)) {
            return Integer.parseInt(num);
        }
        return 0;
    }

    /**
     * 字符串转int 类型集合
     *
     * @param strs 字符串 1,2,3
     * @return list
     */
    public static List<Integer> transitionIntegerList(String strs) {
        List<Integer> idList = new ArrayList<>();
        String[] split = strs.trim().split(",");
        for (String id : split) {
            idList.add(Integer.parseInt(id));
        }
        return idList;
    }

    /**
     * 取集合出现指定个数的元素
     *
     * @param list 集合
     * @param num  元素出现个数
     * @return list
     */
    public static List<Integer> repetitionList(List<Integer> list, Integer num) {
        List<Integer> newList = new ArrayList<>();
        Map<Integer, Long> map = list.stream()
                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
        for (int key : map.keySet()) {
            long val = map.get(key);
            if ((int) val == num) {
                newList.add(key);
            }
        }
        return newList;
    }

    /**
     * 相加integers,integer为null时跳过
     */
    public static int integerSum(Integer... integers) {
        if (integers == null) {
            return 0;
        }

        int sum = 0;
        for (Integer integer : integers) {
            if (integer != null) {
                sum += integer;
            }
        }
        return sum;
    }

    /**
     * 判断是否可以转换成Integer
     */
    public static boolean canParseInt(String str) {
        try {
            Integer.parseInt(str);
        } catch (NumberFormatException e) {
            return false;
        }
        return true;
    }

    /**
     * 判断是否可以转换成Long
     */
    public static boolean canParseLong(String str) {
        try {
            Long.parseLong(str);
        } catch (NumberFormatException e) {
            return false;
        }
        return true;
    }

    /**
     * 数字格式化字符串，不足位数补0
     *
     * @param originNumber 原始数字
     * @param digit 数字位数
     * @return 字符串
     */
    public static String  repair0(Integer originNumber, Integer digit){
        StringBuilder number = new StringBuilder(originNumber + "");
        while (number.length() < digit) {
            number.insert(0, "0");
        }
        return number.toString();
    }

    public static Integer null2Default(Integer originNumber, int defaultNumber) {
        return originNumber == null ? defaultNumber : originNumber;
    }

    public static Long null2Default(Long originNumber, long defaultNumber) {
        return originNumber == null ? defaultNumber : originNumber;
    }

}
